module;
#include <string>
#include <iostream>
#include <type_traits>

export module Code_E_1_0;


//template <typename T> 
//    requires LessThanComparable<T> //concept
//T Max(T a, T b) 
//{
//    return b < a ? a : b;
//}

//class Person
//{
//private:
//    std::string name;
//public:
//    template<typename STR>
//        requires std::is_convertible_v<STR, std::string>
//    explicit Person(STR&& n)
//        : name{ std::forward<STR>(n) }
//    {
//        std::cout << "TMPL-CONSTR for '" << name << "'\n";
//
//    }
//};

//
//template<typename Seq>
//    requires Sequence<Seq> && 
//             EqualityComparable<typename Seq::value_type>
//typename Seq::iterator find(Seq const& seq, typename Seq::value_type const& val)
//{
//    return std::find(seq.begin(), seq.end(), val);
//}
// 
//template<typename T>
//    requires Integral<T> ||
//             FloatingPoint<T>
//T power(T b, T p);

//template<typename T, typename U>
//    requires SomeConcept<T, U>
//auto f(T x, U y) -> decltype(x + y);

//template<LessThanComparable T>
//T max(T a, T b) 
//{
//    return b < a ? a : b;
//}

  
//template<Sequence Seq>
//    requires EqualityComparable<typename Seq::value_type>
//typename Seq::iterator find(Seq const& seq, typename Seq::value_type const& val)
//{
//    return std::find(seq.begin(), seq.end(), val);
//}
 
//template<typename T>
//concept LessThanComparable = requires(T x, T y)
//{
//    {x < y} -> std::convertible_to<bool>;
//};
//
//
//
//template<typename T>
//concept Swappable = requires(T x, T y)
//{
//    swap(x, y);
//};

//
//template<typename Seq>
//concept Sequence = requires(Seq seq)
//{
//    typename Seq::iterator;
//    requires Iterator<typename Seq::iterator>;
//    { seq.begin() } -> std::convertible_to<Seq::iterator>;
//    //...
//};


////C++17
//template<typename T>
//concept BidirectionIterator = ForwardIterator<T> && requires(T it)
//{
//    {--it} -> std::convertible_to <T&>;
//};


//template<typename T>
//concept ForwardIterator = InputIterator<T> && requires
//{
//    typename std::iterator_traits<T>::iterator_category;
//    std::is_convertible_v<std::iterator_traits<T>::iterator_category, std::forward_iterator_tag>;
//};

export
namespace Code_E_1_0 {

    void run()
    {

    }
}
